.TH std::equal_to,not_equal_to,less,greater,less_equal, 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::equal_to,not_equal_to,less,greater,less_equal, \- std::equal_to,not_equal_to,less,greater,less_equal,

.SH Synopsis

   Defined in header <experimental/propagate_const>
   template< class T > struct                                           (library
   equal_to<std::experimental::propagate_const<T>>;                     fundamentals TS
                                                                        v2)
   template< class T > struct                                           (library
   not_equal_to<std::experimental::propagate_const<T>>;                 fundamentals TS
                                                                        v2)
   template< class T > struct                                           (library
   less<std::experimental::propagate_const<T>>;                         fundamentals TS
                                                                        v2)
   template< class T > struct                                           (library
   greater<std::experimental::propagate_const<T>>;                      fundamentals TS
                                                                        v2)
   template< class T > struct                                           (library
   less_equal<std::experimental::propagate_const<T>>;                   fundamentals TS
                                                                        v2)
   template< class T > struct                                           (library
   greater_equal<std::experimental::propagate_const<T>>;                fundamentals TS
                                                                        v2)

   The standard comparison function objects are partially specialized for
   std::experimental::propagate_const<T>.

   Let p.t_ denote the pointer-like object wrapped by a
   std::experimental::propagate_const<T> p, then given objects p and q of type
   std::experimental::propagate_const<T>, the following shall hold:

     * std::equal_to<std::experimental::propagate_const<T>>()(p, q) ==
       std::equal_to<T>()(p.t_, q.t_)
     * std::not_equal_to<std::experimental::propagate_const<T>>()(p, q) ==
       std::not_equal_to<T>()(p.t_, q.t_)
     * std::less<std::experimental::propagate_const<T>>()(p, q) == std::less<T>()(p.t_,
       q.t_)
     * std::greater<std::experimental::propagate_const<T>>()(p, q) ==
       std::greater<T>()(p.t_, q.t_)
     * std::less_equal<std::experimental::propagate_const<T>>()(p, q) ==
       std::less_equal<T>()(p.t_, q.t_)
     * std::greater_equal<std::experimental::propagate_const<T>>()(p, q) ==
       std::greater_equal<T>()(p.t_, q.t_)

.SH Notes

   These specializations ensure that when T is a pointer type, specializations of these
   class templates for std::experimental::propagate_const<T> yield a total order, even
   if the corresponding built-in operators do not.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   equal_to      function object implementing x == y
                 \fI(class template)\fP
   not_equal_to  function object implementing x != y
                 \fI(class template)\fP
   less          function object implementing x < y
                 \fI(class template)\fP
   greater       function object implementing x > y
                 \fI(class template)\fP
   less_equal    function object implementing x <= y
                 \fI(class template)\fP
   greater_equal function object implementing x >= y
                 \fI(class template)\fP

.SH Category:
     * Todo no example
